JavaScript Proxy apdraudētāju validācija: Tīps droša objektu pārtveršana

JavaScript Proxy nodrošina jaudīgu mehānismu, lai pārtvertu un pielāgotu pamata objektu darbības. Viens no visspēcīgākajiem lietošanas gadījumiem ir datu validācija. Izmantojot Proxy apdraudētājus, jūs varat nodrošināt ierobežojumus un tipa drošību objektu īpašībām, tādējādi nodrošinot robustāku un vieglāk uzturamu kodu. Šis emuārs izpētīs, kā izmantot JavaScript Proxy efektīvai objektu validācijai, piedāvājot praktiskus piemērus un norādījumus visiem izstrādātāju līmeņiem. Mēs apskatīsim dažādas apdraudētāju metodes un demonstrēsim, kā tās var izmantot, lai nodrošinātu datu integritāti.

Izpratne par JavaScript Proxy

Pirms pievēršamies validācijai, īsi aplūkosim, kas ir JavaScript Proxy un kā tie darbojas. Proxy objekts iesaiņo citu objektu (mērķi) un pārtver darbības, kas tiek veiktas ar šo mērķi. Proxy ļauj jums definēt pielāgotu uzvedību darbībām, piemēram, iegūstot īpašumu, iestatot īpašumu, izsaucot funkciju vai izveidojot jaunu objektu. Šī pielāgošana tiek panākta, izmantojot apdraudētāju, kas ir objekts, kurā ietilpst metodes, kas pārtver konkrētas darbības.

Pamata sintakse Proxy izveidošanai ir:

            const proxy = new Proxy(target, handler);

            

              
                Copy
              
            
          

• target: Objekts, ko iesaiņot ar Proxy.
• handler: Objekts, kurā ietilpst metodes (slazdi), kas pārtver darbības ar mērķi.

Proxy apdraudētāju metodes validācijai

Apdraudētāja objektā var ietilpt dažādas metodes, katra atbilst atšķirīgai darbībai ar mērķa objektu. Šeit ir dažas no attiecīgākajām metodēm validācijai:

• get(target, property, receiver): Pārtver īpašuma piekļuvi.
• set(target, property, value, receiver): Pārtver īpašuma piešķiršanu.
• apply(target, thisArg, argumentsList): Pārtver funkciju izsaukumus.
• construct(target, argumentsList, newTarget): Pārtver new operatoru.
• deleteProperty(target, property): Pārtver delete operatoru.
• defineProperty(target, property, descriptor): Pārtver īpašuma definīciju.
• has(target, property): Pārtver in operatoru.
• ownKeys(target): Pārtver Object.getOwnPropertyNames(), Object.getOwnPropertySymbols() un Reflect.ownKeys().
• preventExtensions(target): Pārtver Object.preventExtensions().
• getPrototypeOf(target): Pārtver Object.getPrototypeOf().
• setPrototypeOf(target, prototype): Pārtver Object.setPrototypeOf().

Mēs galvenokārt koncentrēsimies uz get, set, apply un construct apdraudētājiem, jo ​​tie visbiežāk tiek izmantoti validācijas nolūkos.

Īpašuma piešķiršanu validēšana ar set apdraudētāju

set apdraudētājs ir ļoti svarīgs īpašuma piešķiršanu validēšanai. Tas ļauj jums pārtvert mēģinājumus modificēt objekta īpašības un nodrošināt ierobežojumus pirms piešķiršanas faktiskās veikšanas.

Piemērs: Tipa pārbaude

Izveidosim Proxy, kas nodrošina tipa pārbaudi Person objekta īpašībām. Mēs nodrošināsim, ka name vienmēr ir virkne, bet age vienmēr ir skaitlis.

            const person = {
  name: 'John Doe',
  age: 30
};

const validator = {
  set: function(target, property, value) {
    if (property === 'name' && typeof value !== 'string') {
      throw new TypeError('Name must be a string');
    }
    if (property === 'age' && typeof value !== 'number') {
      throw new TypeError('Age must be a number');
    }
    // The following line is crucial for ensuring the property is actually set.
    target[property] = value;
    return true; // Indicate success
  }
};

const proxy = new Proxy(person, validator);

proxy.name = 'Jane Smith'; // Works fine
proxy.age = 25; // Works fine

try {
  proxy.age = '40'; // Throws TypeError
} catch (e) {
  console.error(e);
}

console.log(proxy.age); // Output: 25

            

              
                Copy
              
            
          

Šajā piemērā set apdraudētājs pārbauda vērtības tipu, kas tiek piešķirta name un age. Ja tips ir nepareizs, tas izmet TypeError, nepieļaujot piešķiršanu. Ir ļoti svarīgi iekļaut `target[property] = value;` apdraudētāja iekšpusē, lai faktiski iestatītu vērtību; pretējā gadījumā īpašums netiks atjaunināts.

Piemērs: Diapazona validācija

Mēs varam arī validēt, ka īpašums atrodas noteiktā diapazonā. Piemēram, nodrošināsim, ka age vienmēr ir starp 0 un 120.

            const person = {
  name: 'John Doe',
  age: 30
};

const validator = {
  set: function(target, property, value) {
    if (property === 'age') {
      if (typeof value !== 'number') {
        throw new TypeError('Age must be a number');
      }
      if (value < 0 || value > 120) {
        throw new RangeError('Age must be between 0 and 120');
      }
    }
    target[property] = value;
    return true;
  }
};

const proxy = new Proxy(person, validator);

proxy.age = 50; // Works fine

try {
  proxy.age = -5; // Throws RangeError
} catch (e) {
  console.error(e);
}

            

              
                Copy
              
            
          

Īpašuma piekļuvi validēšana ar get apdraudētāju

Lai gan tas nav tik bieži sastopams stingrai validācijai, get apdraudētāju var izmantot, lai veiktu transformācijas vai validācijas, kad tiek piekļūts īpašumam. Piemēram, jūs varētu formatēt telefona numuru vai nodrošināt, ka datums ir derīgs pirms tā atgriešanas.

Piemērs: Tikai lasāmi īpašumi

Jūs varat simulēt tikai lasāmus īpašumus, izmetot kļūdu, kad kāds mēģina piekļūt īpašumam, kuram nevajadzētu piekļūt tieši.

            const config = {
  apiKey: 'secret_key'
};

const validator = {
  get: function(target, property) {
    if (property === 'apiKey') {
      throw new Error('Cannot directly access apiKey. Use a secure method.');
    }
    return target[property];
  }
};

const proxy = new Proxy(config, validator);

try {
  console.log(proxy.apiKey); // Throws Error
} catch (e) {
  console.error(e);
}

            

              
                Copy
              
            
          

Šī pieeja novērš tiešu piekļuvi sensitīviem datiem, piespiežot izstrādātājus izmantot kontrolētāku metodi, lai iegūtu atslēgu (piemēram, funkciju, kas apstrādā autentifikāciju).

Funkciju izsaukumu validēšana ar apply apdraudētāju

apply apdraudētājs ļauj jums pārtvert funkciju izsaukumus un validēt funkcijām nodotās argumentus. Tas ir īpaši noderīgi, lai nodrošinātu, ka funkcijas saņem pareizos argumentu tipus un skaitu.

Piemērs: Argumentu tipa validācija

Izveidosim Proxy, kas validē argumentus, kas tiek nodoti funkcijai, kas aprēķina taisnstūra laukumu.

            function calculateArea(width, height) {
  return width * height;
}

const validator = {
  apply: function(target, thisArg, argumentsList) {
    if (argumentsList.length !== 2) {
      throw new Error('calculateArea requires exactly two arguments: width and height.');
    }

    const width = argumentsList[0];
    const height = argumentsList[1];

    if (typeof width !== 'number' || typeof height !== 'number') {
      throw new TypeError('Width and height must be numbers.');
    }

    if (width <= 0 || height <= 0) {
      throw new RangeError('Width and height must be positive values.');
    }

    return target.apply(thisArg, argumentsList);
  }
};

const proxy = new Proxy(calculateArea, validator);

console.log(proxy(5, 10)); // Output: 50

try {
  console.log(proxy(5)); // Throws Error
} catch (e) {
  console.error(e);
}

try {
  console.log(proxy('5', 10)); // Throws TypeError
} catch (e) {
  console.error(e);
}

            

              
                Copy
              
            
          

Šajā piemērā apply apdraudētājs pārbauda argumentu skaitu un tipus, kas tiek nodoti calculateArea funkcijai. Ja argumenti ir nederīgi, tas izmet kļūdu pirms funkcijas faktiskās izpildes. Būtiskā rinda `return target.apply(thisArg, argumentsList);` faktiski izpilda sākotnējo funkciju ar sniegtajiem argumentiem.

Objektu konstruēšanas validēšana ar construct apdraudētāju

construct apdraudētājs ļauj jums pārtvert new operatoru un validēt konstruktoram nodotos argumentus. Tas ir īpaši noderīgi, lai nodrošinātu ierobežojumus objektiem, kas izveidoti, izmantojot konstruktorus.

Piemērs: Nepieciešamās īpašības

Izveidosim Proxy, kas nodrošina, ka User objekts vienmēr tiek izveidots ar username un email.

            class User {
  constructor(username, email) {
    this.username = username;
    this.email = email;
  }
}

const validator = {
  construct: function(target, argumentsList) {
    if (argumentsList.length !== 2) {
      throw new Error('User constructor requires two arguments: username and email.');
    }

    const username = argumentsList[0];
    const email = argumentsList[1];

    if (typeof username !== 'string' || username.length === 0) {
      throw new TypeError('Username must be a non-empty string.');
    }

    if (typeof email !== 'string' || !email.includes('@')) {
      throw new TypeError('Email must be a valid email address.');
    }

    return new target(...argumentsList);
  }
};

const UserProxy = new Proxy(User, validator);

const user1 = new UserProxy('john.doe', 'john.doe@example.com'); // Works fine

try {
  const user2 = new UserProxy('john.doe'); // Throws Error
} catch (e) {
  console.error(e);
}

try {
  const user3 = new UserProxy('john.doe', 'invalid_email'); // Throws TypeError
} catch (e) {
  console.error(e);
}

console.log(user1);

            

              
                Copy
              
            
          

Šajā piemērā construct apdraudētājs pārbauda argumentu skaitu un tipus, kas tiek nodoti User konstruktoram. Ja argumenti ir nederīgi, tas izmet kļūdu pirms objekta izveides. Rinda `return new target(...argumentsList);` faktiski izveido jaunu klases instanci, izmantojot sniegtos argumentus.

Uzlabotas validācijas tehnikas

Papildus pamata tipa pārbaudēm un diapazona validācijām, Proxy var izmantot sarežģītākiem validācijas scenārijiem.

Starp-īpašumu validācija

Jūs varat izmantot Proxy, lai validētu attiecības starp dažādiem īpašumiem. Piemēram, jūs varētu vēlēties nodrošināt, ka sākuma datums vienmēr ir pirms beigu datuma.

            const event = {
  startDate: '2024-01-15',
  endDate: '2024-01-20'
};

const validator = {
  set: function(target, property, value) {
    target[property] = value; // Set the value first

    if (property === 'endDate' && target.startDate > target.endDate) {
      throw new Error('End date must be after start date.');
    }

    return true;
  }
};

const proxy = new Proxy(event, validator);

proxy.endDate = '2024-01-25'; // Works fine

try {
  proxy.endDate = '2024-01-10'; // Throws Error
} catch (e) {
  console.error(e);
}

            

              
                Copy
              
            
          

Asinhronā validācija

Lai gan tas nav tik bieži, jūs varat izmantot Proxy ar asinhronām operācijām sarežģītākiem validācijas scenārijiem. Tas varētu ietvert API zvanus, lai validētu datus attiecībā pret ārējiem avotiem.

Svarīga piezīme: Asinhronās operācijas Proxy apdraudētāju iekšienē var būt sarežģītas, un tām jābūt rūpīgi apstrādātām, lai izvairītos no notikumu cilpas bloķēšanas. Bieži vien ir labāk veikt asinhronu validāciju ārpus Proxy apdraudētāja un pēc tam izmantot Proxy, lai nodrošinātu rezultātus.

Priekšrocības, izmantojot Proxy validācijai

• Centralizēta validācijas loģika: Proxy ļauj jums centralizēt validācijas loģiku vienā vietā, padarot to vieglāk uzturēt un atjaunināt.
• Uzlabota koda lasāmība: Atkāpjot validācijas loģiku no galvenās objektu loģikas, jūs varat uzlabot sava koda lasāmību un uzturēšanu.
• Pastiprināta tipa drošība: Proxy palīdz nodrošināt tipa drošību, samazinot kļūdu risku, ko izraisa nepareizi datu tipi.
• Elastība un pielāgošana: Proxy nodrošina augstu elastības līmeni, ļaujot jums pielāgot validācijas noteikumus, lai tie atbilstu jūsu lietojumprogrammas īpašajām vajadzībām.

Proxy izmantošanas ierobežojumi

• Veiktspējas pārklājums: Proxy rada nelielu veiktspējas pārklājumu, jo tiek pārtvertas objektu darbības. Šis pārklājums lielākajai daļai lietojumprogrammu parasti ir niecīgs, taču tas ir svarīgi ņemt vērā veiktspējas kritiskos scenārijos.
• Saderība: Lai gan Proxy tiek atbalstīti modernajos pārlūkos un Node.js, tie netiek atbalstīti vecākās vidēs. Lai nodrošinātu saderību ar vecākiem pārlūkiem, jums var būt jāizmanto polifīli.
• Debugošana: Debugošana kodam, kas izmanto Proxy, var būt nedaudz sarežģītāka, jo tiek pārtvertas objektu darbības. Tomēr mūsdienu izstrādes rīki nodrošina labu atbalstu Proxy debugošanai.

Labākā prakse Proxy apdraudētāju validācijai

• Saglabājiet apdraudētājus vienkāršus: Izvairieties no sarežģītas loģikas Proxy apdraudētāju iekšienē, lai samazinātu veiktspējas pārklājumu un uzlabotu lasāmību.
• Sniedziet skaidrus kļūdu ziņojumus: Izmetiet informatīvus kļūdu ziņojumus, kas palīdz izstrādātājiem saprast, kāpēc validācija neizdevās.
• Apsveriet veiktspēju: Ņemiet vērā Proxy ietekmi uz veiktspēju, īpaši veiktspējas kritiskās lietojumprogrammās.
• Izmantojiet piesardzīgi: Nepārmērējiet Proxy lietošanu. Izmantojiet tos stratēģiski validācijai un citiem metaprogrammēšanas uzdevumiem, kur tie sniedz skaidru labumu.
• Testējiet rūpīgi: Rūpīgi pārbaudiet savu Proxy balstītu validācijas loģiku, lai nodrošinātu, ka tā darbojas, kā paredzēts visos scenārijos.

Globālie apsvērumi validācijai

Izstrādājot lietojumprogrammas globālai auditorijai, ir svarīgi ņemt vērā kultūras atšķirības un reģionālās atšķirības, īstenojot validācijas noteikumus. Šeit ir daži galvenie apsvērumi:

• Datuma un laika formāti: Izmantojiet tādu bibliotēku kā Moment.js vai date-fns, lai pareizi apstrādātu datuma un laika formātus dažādām lokalizācijām. Piemēram, Amerikas Savienotajās Valstīs datumi bieži tiek formatēti kā MM/DD/YYYY, savukārt Eiropā tie parasti tiek formatēti kā DD/MM/YYYY.
• Numuru formāti: Apziniesiet dažādus numuru formātus, ieskaitot decimāldaļas atdalītājus un tūkstošu atdalītājus. Dažās valstīs decimāldaļas atdalītājam tiek izmantota komats, savukārt citās tiek izmantots punkts.
• Valūtas formāti: Parādiet valūtas vērtības pareizajā formātā lietotāja lokalizācijai, ieskaitot atbilstošo valūtas simbolu un decimālo precizitāti.
• Adrešu formāti: Adrešu formāti visā pasaulē ievērojami atšķiras. Apsveriet iespēju izmantot bibliotēku vai API, kas atbalsta starptautisko adrešu validāciju un formatēšanu.
• Tālruņu numuru formāti: Izmantojiet bibliotēku, kas atbalsta starptautisko tālruņu numuru validāciju un formatēšanu, lai nodrošinātu, ka tālruņu numuri tiek ievadīti pareizi.
• Vārdu formāti: Apziniesiet, ka vārdu formāti dažādās kultūrās var atšķirties. Dažas kultūras izmanto vārdu, kam seko uzvārds, savukārt citas izmanto uzvārdu, kam seko vārds. Arī dažām kultūrām ir vairāki vārdi vai uzvārdi.
• Rakstzīmju kopas: Nodrošiniet, ka jūsu lietojumprogramma atbalsta dažādas rakstzīmju kopas un kodējumus, lai pielāgotu vārdus, adreses un citus teksta datus dažādās valodās.
• Kultūras jutīgums: Esiet apzinīgs par kultūras jutīgumu, izstrādājot validācijas noteikumus. Piemēram, noteikta veida dati var tikt uzskatīti par privātiem vai sensitīviem dažās kultūrās.

Piemērs: Starptautisko tālruņu numuru validācija

            // Assuming you're using a library like "google-libphonenumber"

import { parsePhoneNumberFromString, AsYouType } from 'google-libphonenumber';

function validatePhoneNumber(phoneNumber, countryCode) {
  try {
    const number = parsePhoneNumberFromString(phoneNumber, countryCode);
    if (number && number.isValid()) {
      return true;
    } else {
      return false;
    }
  } catch (error) {
    return false; // Invalid phone number format
  }
}

// Example Usage (Germany)
const isValidGermanNumber = validatePhoneNumber('+4917612345678', 'DE');
console.log('Is valid German number:', isValidGermanNumber); // Output: true

// Example Usage (United States)
const isValidUSNumber = validatePhoneNumber('+15551234567', 'US');
console.log('Is valid US number:', isValidUSNumber); // Output: true

            

              
                Copy
              
            
          

Nobeigums

JavaScript Proxy nodrošina jaudīgu un elastīgu mehānismu, lai jūsu lietojumprogrammās ieviestu validācijas loģiku. Izmantojot Proxy apdraudētājus, jūs varat nodrošināt ierobežojumus un tipa drošību objektu īpašībām, funkciju argumentiem un objektu konstruēšanai, tādējādi nodrošinot robustāku, vieglāk uzturamu un drošāku kodu. Atcerieties ņemt vērā veiktspējas sekas un saderības jautājumus, lietojot Proxy, un vienmēr rūpīgi pārbaudiet savu validācijas loģiku. Ievērojot šajā emuārā izklāstīto labāko praksi, jūs varat efektīvi izmantot Proxy, lai uzlabotu savu JavaScript lietojumprogrammu kvalitāti un uzticamību, apkalpojot globālu auditoriju ar lokalizētām validācijas stratēģijām.